home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2007 December / PCWKCD1207B.iso / Blogowanie poza sfera / Flock 1.0 beta / flock-1.0RC3.en-US.win32.exe / flock / components / flockPollerService.js < prev    next >
Text File  |  2007-10-18  |  16KB  |  540 lines
  1. // BEGIN FLOCK GPL
  2. // 
  3. // Copyright Flock Inc. 2005-2007
  4. // http://flock.com
  5. // 
  6. // This file may be used under the terms of of the
  7. // GNU General Public License Version 2 or later (the "GPL"),
  8. // http://www.gnu.org/licenses/gpl.html
  9. // 
  10. // Software distributed under the License is distributed on an "AS IS" basis,
  11. // WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  12. // for the specific language governing rights and limitations under the
  13. // License.
  14. // 
  15. // END FLOCK GPL
  16.  
  17. const PS_CONTRACTID = '@flock.com/poller-service;1';
  18. const PS_CLASSID    = Components.ID('{a2b4cd0e-804b-4578-8c3c-4b61f8c1047a}');
  19. const PS_CLASSNAME  = 'Flock Poller';
  20.  
  21.  
  22. const PREF_POLLER_BRANCH            = 'flock.poller'
  23. const PREF_REFRESH_DELAY            = '.refreshDelay';
  24. const PREF_REFRESH_TIMEOUT          = '.refreshTimeout';
  25. const PREF_DEFAULT_REFRESH_INTERVAL = '.defaultRefreshInterval';
  26. const PREF_MAX_CONCURRENT_REFRESHES = '.maxConcurrentRefreshes';
  27.  
  28. // According to Mozilla docs, timers can't be set for more than approximately
  29. // 6 hours. We'll limit to 4 hours just to be conservative.
  30. const MAX_TIMER_INTERVAL = 4 * 60 * 60 * 1000;
  31.  
  32. // Delay actual polling for 30 seconds after component initialization, so
  33. // there is reduced contention among other browser startup operations
  34. const STARTUP_DELAY = 30 * 1000;
  35.  
  36.  
  37. const Ci = Components.interfaces;
  38. const Cc = Components.classes;
  39. const Cr = Components.results;
  40.  
  41.  
  42. function getObserverService() {
  43.   return Cc['@mozilla.org/observer-service;1']
  44.     .getService(Ci.nsIObserverService);
  45. } 
  46.  
  47.  
  48. function RefreshListener(poller, urn, serviceId) {
  49.   this._poller = poller;
  50.   this._urn = urn;
  51.   this._serviceId = serviceId;
  52. }
  53.  
  54. RefreshListener.prototype = {
  55.   onResult: function PSL_onResult() { 
  56.     this._poller._logger.info('Successful refresh for ' + this._urn);
  57.     this._poller._finishedRefresh(this._urn);
  58.   },
  59.   onError: function PSL_onError(error) {
  60.     this._poller._logger.error('The service ' + this._serviceId + ' returned an ' +
  61.                                'error while refreshing ' + this._urn);
  62.     this._poller._finishedRefresh(this._urn);
  63.   },
  64.   notify: function PSL_notify(timer) {
  65.     this._poller._logger.error('The service ' + this._serviceId + ' timed out ' +
  66.                                'while refreshing ' + this._urn);
  67.     this._poller._finishedRefresh(this._urn);
  68.   },
  69.   QueryInterface: function PSL_QueryInterface(iid) {
  70.     if (iid.equals(Ci.flockIPollerListener) ||
  71.         iid.equals(Ci.nsITimerCallback) ||
  72.         iid.equals(Ci.nsISupports))
  73.       return this;
  74.     throw Cr.NS_ERROR_NO_INTERFACE;
  75.   }
  76. }
  77.  
  78.  
  79. function PollerService() {
  80.   var obs = getObserverService();
  81.   obs.addObserver(this, 'flock-data-ready', false);
  82.   obs.addObserver(this, 'xpcom-shutdown', false);
  83. }
  84.  
  85. PollerService.prototype = {
  86.   _start: function PS__start() {
  87.     this._logger = Cc['@flock.com/logger;1'].createInstance(Ci.flockILogger);
  88.     this._logger.init('poller');
  89.     this._logger.info('starting up...');
  90.  
  91.     this._profiler = Cc["@flock.com/profiler;1"].getService(Ci.flockIProfiler);
  92.     var evtID = this._profiler.profileEventStart('poller-start');
  93.  
  94.     this._timer = Cc['@mozilla.org/timer;1'].createInstance(Ci.nsITimer);
  95.  
  96.     this._coop = Cc["@flock.com/singleton;1"]
  97.                  .getService(Ci.flockISingleton)
  98.                  .getSingleton("chrome://flock/content/common/load-faves-coop.js")
  99.                  .wrappedJSObject;
  100.  
  101.     var prefService = Cc['@mozilla.org/preferences-service;1']
  102.       .getService(Ci.nsIPrefBranch2);
  103.     prefService.addObserver(PREF_POLLER_BRANCH, this, false);
  104.  
  105.     this.observe(null, 'nsPref:changed', PREF_REFRESH_DELAY);
  106.     this.observe(null, 'nsPref:changed', PREF_REFRESH_TIMEOUT);
  107.     this.observe(null, 'nsPref:changed', PREF_DEFAULT_REFRESH_INTERVAL);
  108.     this.observe(null, 'nsPref:changed', PREF_MAX_CONCURRENT_REFRESHES);
  109.  
  110.     this._initializeQueue();
  111.     this._watchRDFEvents();
  112.  
  113.     this._profiler.profileEventEnd(evtID, "");
  114.   },
  115.   _shutdown: function PS__shutdown() {
  116.     var prefService = Cc['@mozilla.org/preferences-service;1']
  117.       .getService(Ci.nsIPrefBranch2);
  118.     prefService.removeObserver(PREF_POLLER_BRANCH, this);
  119.  
  120.     this._timer.cancel();
  121.     this._timer = null;
  122.   },
  123.  
  124.   _prefChanged: function PS__prefChanged(pref) {
  125.     var prefService = Cc['@mozilla.org/preferences-service;1']
  126.       .getService(Ci.nsIPrefService);
  127.     var prefBranch = prefService.getBranch(PREF_POLLER_BRANCH);
  128.  
  129.     switch (pref) {
  130.       case PREF_REFRESH_DELAY:
  131.         this._refreshDelay = prefBranch.getIntPref(pref);
  132.         break;
  133.  
  134.       case PREF_REFRESH_TIMEOUT:
  135.         this._refreshTimeout = prefBranch.getIntPref(pref);
  136.         break;
  137.  
  138.       case PREF_DEFAULT_REFRESH_INTERVAL:
  139.         this._defaultRefreshInterval = prefBranch.getIntPref(pref);
  140.         break;
  141.  
  142.       case PREF_MAX_CONCURRENT_REFRESHES:
  143.         this._maxConcurrentRefreshes = prefBranch.getIntPref(pref);
  144.         break;
  145.     }
  146.   },
  147.  
  148.   _watchRDFEvents: function PS__watchRDFEvents() {
  149.     var RDFS = Cc['@mozilla.org/rdf/rdf-service;1']
  150.       .getService(Ci.nsIRDFService);
  151.     var nextRefresh = RDFS.GetResource('http://flock.com/rdf#nextRefresh');
  152.     var isPollable = RDFS.GetResource('http://flock.com/rdf#isPollable');
  153.  
  154.     var faves = Cc['@mozilla.org/rdf/datasource;1?name=flock-favorites']
  155.       .getService(Ci.flockIRDFObservable);
  156.     faves.addArcObserver(Ci.flockIRDFObserver.TYPE_ALL, null, nextRefresh, null,
  157.                          this);
  158.     faves.addArcObserver(Ci.flockIRDFObserver.TYPE_ALL, null, isPollable, null,
  159.                          this);
  160.   },
  161.   rdfChanged: function PS_rdfChanged(ds, type, rsrc, pred, obj, oldObj) {
  162.     var pollable = this._coop.get_from_resource(rsrc);
  163.  
  164.     if (pollable && pollable.isPollable) {
  165.       if (pollable.nextRefresh)
  166.         this._addToQueue(pollable);
  167.       else
  168.         pollable.nextRefresh = new Date();
  169.     } else {
  170.       rsrc.QueryInterface(Ci.nsIRDFResource);
  171.       this._removeFromQueue(rsrc.ValueUTF8);
  172.     }
  173.   },
  174.  
  175.   _initializeQueue: function PS__initializeQueue() {
  176.     var queue = [];
  177.     var dates = {};
  178.  
  179.     var RDFS = Cc['@mozilla.org/rdf/rdf-service;1']
  180.       .getService(Ci.nsIRDFService);
  181.     var isPollable = RDFS.GetResource('http://flock.com/rdf#isPollable');
  182.  
  183.     var faves = Cc['@mozilla.org/rdf/datasource;1?name=flock-favorites']
  184.       .getService(Ci.nsIRDFDataSource);
  185.  
  186.     var pollables = faves.GetSources(isPollable, RDFS.GetLiteral('true'), true);
  187.     while (pollables.hasMoreElements()) {
  188.       var pollable = this._coop.get_from_resource(pollables.getNext());
  189.  
  190.       var urn = pollable.id();
  191.       queue.push(urn);
  192.  
  193.       if (!pollable.nextRefresh)
  194.         pollable.nextRefresh = new Date();
  195.  
  196.       dates[urn] = pollable.nextRefresh;
  197.     }
  198.  
  199.     function sorter(a, b) {
  200.       return dates[a] - dates[b];
  201.     }
  202.     queue.sort(sorter);
  203.  
  204.     this._queue = queue;
  205.     this._dates = dates;
  206.  
  207.     this._refreshing = {};
  208.     this._refreshOrder = [];
  209.  
  210.     this._lastRefresh = new Date(0);
  211.  
  212.     this._logger.debug('queue initialized: ' + this._queue.toSource());
  213.  
  214.     this._initTimer(STARTUP_DELAY);
  215.   },
  216.  
  217.   _addToQueue: function PS__addToQueue(obj) {
  218.     var urn = obj.id();
  219.     var nextRefresh = obj.nextRefresh;
  220.  
  221.     var date = this._dates[urn];
  222.     if (date) {
  223.       if (date - nextRefresh == 0)
  224.         return;
  225.       else
  226.         this._queue.splice(this._queue.indexOf(urn), 1);
  227.     }
  228.  
  229.     this._dates[urn] = nextRefresh;
  230.  
  231.     for (var i = 0; i < this._queue.length; i++) {
  232.       var date = this._dates[this._queue[i]];
  233.       if (nextRefresh < date) {
  234.         this._queue.splice(i, 0, urn);
  235.         if (i == 0)
  236.           this._recalculateTimer();
  237.  
  238.         this._logger.debug('queue updated: ' + this._queue.toSource());
  239.         return;
  240.       }
  241.     }
  242.  
  243.     this._queue.push(urn);
  244.     if (this._queue.length == 1)
  245.       this._recalculateTimer();
  246.  
  247.     this._logger.debug('queue updated: ' + this._queue.toSource());
  248.   },
  249.  
  250.   _removeFromQueue: function PS__removeFromQueue(urn) {
  251.     var date = this._dates[urn];
  252.     if (!date)
  253.       return;
  254.  
  255.     delete this._dates[urn];
  256.  
  257.     var index = this._queue.indexOf(urn);
  258.     if (index == 0) {
  259.       this._queue.shift();
  260.       this._recalculateTimer();
  261.     } else {
  262.       this._queue.splice(index, 1);
  263.     }
  264.  
  265.     this._logger.debug('queue updated: ' + this._queue.toSource());
  266.   },
  267.  
  268.   _initTimer: function PS__initTimer(interval) {
  269.     this._logger.debug('next refresh: ' + interval / 1000);
  270.     this._timer.initWithCallback(this, interval, Ci.nsITimer.TYPE_ONE_SHOT);
  271.   },
  272.   _recalculateTimer: function PS__recalculateTimer() {
  273.     this._timer.cancel();
  274.  
  275.     if (this._queue.length) {
  276.       var date = this._dates[this._queue[0]];
  277.       var now = new Date();
  278.  
  279.       var interval = date > now ? date - now : 0;
  280.       interval = Math.min(interval, MAX_TIMER_INTERVAL);
  281.  
  282.       if (this._refreshOrder.length) {
  283.         var urn = this._refreshOrder[this._refreshOrder.length - 1];
  284.         var start = this._refreshing[urn].start;
  285.         var delay = (this._refreshDelay * 1000) - (now - start);
  286.         interval = Math.max(interval, delay);
  287.  
  288.         if (this._refreshOrder.length > this._maxConcurrentRefreshes - 1) {
  289.           urn = this._refreshOrder[0];
  290.           start = this._refreshing[urn].start;
  291.           delay = (this._refreshTimeout * 1000) - (now - start);
  292.           interval = Math.max(interval, delay);
  293.         }
  294.       } else {
  295.         var delay = (this._refreshDelay * 1000) - (now - this._lastRefresh);
  296.         interval = Math.max(interval, delay);
  297.       }
  298.  
  299.       this._initTimer(interval);
  300.     }
  301.   },
  302.  
  303.   _finishedRefresh: function PS__finishedRefresh(urn) {
  304.     var index = this._refreshOrder.indexOf(urn);
  305.     if (index == -1)
  306.       return;
  307.  
  308.     var refreshInfo = this._refreshing[urn]
  309.  
  310.     if (refreshInfo.timer) {
  311.       refreshInfo.timer.cancel();
  312.     }
  313.  
  314.     delete this._refreshing[urn];
  315.     this._refreshOrder.splice(index, 1);
  316.  
  317.     var obj = this._coop.get(urn);
  318.     if (!obj)
  319.       return;
  320.  
  321.     obj.isRefreshing = false;
  322.  
  323.     var now = new Date();
  324.     if (obj.nextRefresh < now) {
  325.       var refreshInterval = obj.refreshInterval ? obj.refreshInterval
  326.                                                 : this._defaultRefreshInterval;
  327.  
  328.       obj.nextRefresh = new Date(now.getTime() + refreshInterval * 1000);
  329.     }
  330.  
  331.     this._recalculateTimer();
  332.  
  333.     var obs = getObserverService();
  334.     obs.notifyObservers(null, "refresh-myworld", null);
  335.   },
  336.   _refresh: function PS__refresh(obj) {
  337.     var urn = obj.id();
  338.     if (this._refreshing[urn])
  339.       return;
  340.  
  341.     var serviceId = obj.serviceId;
  342.     this._logger.debug('serviceId = ' + serviceId);
  343.  
  344.     var service = null;
  345.     if (serviceId && Cc[serviceId]) {
  346.       try {
  347.         service = Cc[serviceId].getService(Ci.flockIPollingService);
  348.       }
  349.       catch (e) {
  350.         this._logger.error('Problem getting "' + serviceId + '" as a ' +
  351.                            'flockIPollingService, while trying to refresh ' + 
  352.                            urn);
  353.       }
  354.     }
  355.  
  356.     if (service) {
  357.       this._logger.info('Refreshing ' + urn);
  358.       try {
  359.         var now = new Date();
  360.  
  361.         this._refreshing[urn] = { start: now };
  362.         this._refreshOrder.push(urn);
  363.  
  364.         obj.isRefreshing = true;
  365.  
  366.         var listener = new RefreshListener(this, urn, serviceId);
  367.         service.refresh(urn, listener);
  368.  
  369.         var refreshInfo = this._refreshing[urn];
  370.         if (refreshInfo) {
  371.           var timer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer);
  372.           refreshInfo.timer = timer;
  373.           timer.initWithCallback(listener, this._refreshTimeout * 1000,
  374.                                  Ci.nsITimer.TYPE_ONE_SHOT);
  375.         }
  376.  
  377.         this._lastRefresh = now;
  378.       }
  379.       catch (e) {
  380.         this._logger.error("Exception while "
  381.                            + serviceId
  382.                            + " was refreshing a stream: "
  383.                            + e);
  384.         this._finishedRefresh(urn);
  385.       }
  386.     } else {
  387.       this._logger.error('Problem getting the service, while trying to ' +
  388.                          'refresh ' + urn);
  389.     }
  390.   },
  391.  
  392.   notify: function PS_notify(timer) {
  393.     var urn = this._queue[0];
  394.     var date = this._dates[urn];
  395.  
  396.     var now = new Date();
  397.     if (now < date) {
  398.       this._recalculateTimer();
  399.       return;
  400.     }
  401.  
  402.     this._queue.shift();  
  403.     delete this._dates[urn];
  404.  
  405.     var obj = this._coop.get(urn);
  406.     if (obj)
  407.       this._refresh(this._coop.get(urn));
  408.     else
  409.       this._logger.warn('trying to refresh nonexistent object: ' + urn);
  410.  
  411.     this._recalculateTimer();
  412.   },
  413.  
  414.   observe: function PS_observe(subject, topic, state) {
  415.     var obs = getObserverService();
  416.  
  417.     switch (topic) {
  418.       case 'flock-data-ready':
  419.         obs.removeObserver(this, 'flock-data-ready');
  420.         this._start();
  421.         break;
  422.  
  423.       case 'xpcom-shutdown':
  424.         obs.removeObserver(this, 'xpcom-shutdown');
  425.         this._shutdown();
  426.         break;
  427.  
  428.       case 'nsPref:changed':
  429.         this._prefChanged(state);
  430.         break;
  431.     }
  432.   },
  433.  
  434.   forceRefresh: function PS_forceRefresh(urn) {
  435.     var obj = this._coop.get(urn);
  436.     if (!obj)
  437.       throw 'URN ' + urn + ' does not exist'; 
  438.  
  439.     obj.nextRefresh = new Date(0);
  440.   },
  441.  
  442.   getInterfaces: function PS_getInterfaces(countRef) {
  443.     var interfaces = [Ci.flockIPollerService, Ci.flockIRDFObserver,
  444.                       Ci.nsITimerCallback, Ci.nsIObserver, Ci.nsIClassInfo,
  445.                       Ci.nsISupports];
  446.     countRef.value = interfaces.length;
  447.     return interfaces;
  448.   },
  449.   getHelperForLanguage: function PS_getHelperForLanguage(language) {
  450.     return null;
  451.   },
  452.   contractID: PS_CONTRACTID,
  453.   classDescription: PS_CLASSNAME,
  454.   classID: PS_CLASSID,
  455.   implementationLanguage: Ci.nsIProgrammingLanguage.JAVASCRIPT,
  456.   flags: Ci.nsIClassInfo.SINGLETON,
  457.  
  458.   QueryInterface: function PS_QueryInterface(iid) {
  459.     if (iid.equals(Ci.flockIPollerService) ||
  460.         iid.equals(Ci.flockIRDFObserver) ||
  461.         iid.equals(Ci.nsITimerCallback) ||
  462.         iid.equals(Ci.nsIObserver) ||
  463.         iid.equals(Ci.nsIClassInfo) ||
  464.         iid.equals(Ci.nsISupports))
  465.       return this;
  466.     throw Cr.NS_ERROR_NO_INTERFACE;
  467.   }
  468. }
  469.  
  470.  
  471. function GenericComponentFactory(ctor) {
  472.   this._ctor = ctor;
  473. }
  474.  
  475. GenericComponentFactory.prototype = {
  476.  
  477.   _ctor: null,
  478.  
  479.   // nsIFactory
  480.   createInstance: function(outer, iid) {
  481.     if (outer != null)
  482.       throw Cr.NS_ERROR_NO_AGGREGATION;
  483.     return (new this._ctor()).QueryInterface(iid);
  484.   },
  485.  
  486.   // nsISupports
  487.   QueryInterface: function(iid) {
  488.     if (iid.equals(Ci.nsIFactory) ||
  489.         iid.equals(Ci.nsISupports))
  490.       return this;
  491.     throw Cr.NS_ERROR_NO_INTERFACE;
  492.   },
  493. };
  494.  
  495. var Module = {
  496.   QueryInterface: function(iid) {
  497.     if (iid.equals(Ci.nsIModule) ||
  498.         iid.equals(Ci.nsISupports))
  499.       return this;
  500.  
  501.     throw Cr.NS_ERROR_NO_INTERFACE;
  502.   },
  503.  
  504.   getClassObject: function(cm, cid, iid) {
  505.     if (!iid.equals(Ci.nsIFactory))
  506.       throw Cr.NS_ERROR_NOT_IMPLEMENTED;
  507.  
  508.     if (cid.equals(PS_CLASSID))
  509.       return new GenericComponentFactory(PollerService);
  510.  
  511.     throw Cr.NS_ERROR_NO_INTERFACE;
  512.   },
  513.  
  514.   registerSelf: function(cm, file, location, type) {
  515.     var cr = cm.QueryInterface(Ci.nsIComponentRegistrar);
  516.     cr.registerFactoryLocation(PS_CLASSID, PS_CLASSNAME, PS_CONTRACTID,
  517.                                file, location, type);
  518.  
  519.     var catman = Cc['@mozilla.org/categorymanager;1']
  520.       .getService(Ci.nsICategoryManager);
  521.     catman.addCategoryEntry('flock-startup', PS_CLASSNAME,
  522.                             'service,' + PS_CONTRACTID,
  523.                             true, true);
  524.   },
  525.  
  526.   unregisterSelf: function(cm, location, type) {
  527.     var cr = cm.QueryInterface(Ci.nsIComponentRegistrar);
  528.     cr.unregisterFactoryLocation(PS_CLASSID, location);
  529.   },
  530.  
  531.   canUnload: function(cm) {
  532.     return true;
  533.   },
  534. };
  535.  
  536. function NSGetModule(compMgr, fileSpec)
  537. {
  538.   return Module;
  539. }
  540.